The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you open a pull request for review, mark a draft as ready, or comment "@codex review". If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex fix this CI failure" or "@codex address that feedback".

package.json (1)

91-97: sass + sass-embedded together: consider dropping one

build.mjs uses sass-embedded as the loader implementation. Keeping both sass and sass-embedded increases install size; unless another tool requires sass, consider removing sass to slim CI installs. If you do need both, no action needed.

.github/workflows/pre-release-build.yml (1)

35-43: Broaden the webpack cache key to include build.mjs

Including build.mjs in the cache key avoids restoring a cache that webpack will immediately invalidate due to buildDependencies. This saves time and bandwidth.

Apply:

-          key: ${{ runner.os }}-webpack-${{ hashFiles('**/package-lock.json') }}
+          key: ${{ runner.os }}-webpack-${{ hashFiles('**/package-lock.json', 'build.mjs') }}
-          restore-keys: |
-            ${{ runner.os }}-webpack-
+          restore-keys: |
+            ${{ runner.os }}-webpack-

.github/copilot-instructions.md (1)

33-35: Tiny grammar/polish

Make the performance defaults sentence crisper.

-Performance defaults: esbuild is used for JS/CSS minification; dev injects CSS via style-loader,
-prod extracts CSS via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.
+Performance defaults: esbuild handles JS/CSS minification; in development CSS is injected via style-loader,
+in production CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you open a pull request for review, mark a draft as ready, or comment "@codex review". If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex fix this CI failure" or "@codex address that feedback".

build.mjs (4)

35-56: Thread worker calculation has proper bounds checking.

The logic for determining thread workers is robust with proper validation and capping to CPU count. Good defensive programming.

---

57-58: Consider making the production pool timeout configurable.

The hardcoded 2000ms timeout could be made configurable for different environments.

-const PRODUCTION_POOL_TIMEOUT_MS = 2000
+const PRODUCTION_POOL_TIMEOUT_MS = process.env.BUILD_POOL_TIMEOUT ? 
+  parseInt(process.env.BUILD_POOL_TIMEOUT, 10) : 2000

---

372-385: Add logging for skipped files in development.

When files are skipped (especially CSS placeholders), it would be helpful to log this for debugging purposes.

           if (!isProduction && isCss) return
+          console.log(`[build] Skipping missing CSS file: ${entryPoint.src} (placeholder will be created)`)

---

456-508: Parallel build implementation with temporary directories is well-structured.

The parallel and sequential build paths are properly implemented with appropriate cleanup of temporary directories. The error handling ensures failed builds are properly reported.

package.json (1)

92-94: Consider pinning sass-embedded to match sass version.

While both sass and sass-embedded are at ^1.91.0, having separate version specs could lead to divergence. Consider using a single shared version constraint or removing the redundant sass package if sass-embedded is the primary implementation.

If sass-embedded is the primary Sass implementation being used in build.mjs, you could remove the regular sass package:

-    "sass": "^1.91.0",
     "sass-embedded": "^1.91.0",

.github/workflows/pre-release-build.yml (1)

29-35: Consider adding npm cache version to the cache key.

The npm cache key only includes the OS and package-lock hash. If npm itself is upgraded, the cache structure might change. Consider including npm version in the key.

-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          key: ${{ runner.os }}-npm-v${{ steps.npm-version.outputs.version }}-${{ hashFiles('**/package-lock.json') }}

You would need to add a step to capture npm version:

      - name: Get npm version
        id: npm-version
        run: echo "version=$(npm -v)" >> $GITHUB_OUTPUT

.github/copilot-instructions.md (1)

33-34: Fix minor grammar issue in the documentation.

There's a minor grammar issue flagged by static analysis.

-Performance defaults: esbuild handles JS/CSS minification; in development CSS is injected via style-loader,
-in production CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.
+Performance defaults: esbuild handles JS/CSS minification; in development CSS is injected via style-loader;
+in production CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.

build.mjs (1)

20-34: Consider extracting cache compression validation to a helper function.

The cache compression validation logic is quite verbose and could be simplified.

-const cacheCompressionEnv = process.env.BUILD_CACHE_COMPRESSION
-let cacheCompressionOption
-if (cacheCompressionEnv != null) {
-  const v = String(cacheCompressionEnv).trim().toLowerCase()
-  if (v === '' || v === '0' || v === 'false' || v === 'none') {
-    cacheCompressionOption = false
-  } else if (v === 'gzip' || v === 'brotli') {
-    cacheCompressionOption = v
-  } else {
-    console.warn(
-      `[build] Unknown BUILD_CACHE_COMPRESSION="${cacheCompressionEnv}", defaulting to no compression`,
-    )
-    cacheCompressionOption = false
-  }
-}
+function parseCacheCompression(env) {
+  if (env == null) return undefined
+  const v = String(env).trim().toLowerCase()
+  if (['', '0', 'false', 'none'].includes(v)) return false
+  if (['gzip', 'brotli'].includes(v)) return v
+  console.warn(`[build] Unknown BUILD_CACHE_COMPRESSION="${env}", defaulting to no compression`)
+  return false
+}
+const cacheCompressionOption = parseCacheCompression(process.env.BUILD_CACHE_COMPRESSION)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

build.mjs (6)

17-17: Simplify boolean logic for parallelBuild

The ternary operator with explicit boolean values is unnecessarily verbose.

-const parallelBuild = process.env.BUILD_PARALLEL === '0' ? false : true
+const parallelBuild = process.env.BUILD_PARALLEL !== '0'

---

35-42: Simplify CPU count fallback logic

The CPU count determination logic is overly complex and can be simplified using Math.max.

-let cpuCount = 1
-try {
-  const cpuInfo = os.cpus && os.cpus()
-  const len = Array.isArray(cpuInfo) ? cpuInfo.length : 0
-  cpuCount = Number.isInteger(len) && len > 0 ? len : 1
-} catch {
-  cpuCount = 1
-}
+const cpuCount = Math.max(1, os.cpus()?.length || 1)

---

130-130: Verify source map configuration change impact

The change from 'inline-source-map' to 'cheap-module-source-map' improves build performance but creates external .map files that need to be copied in development builds.

#!/bin/bash
# Check if .map files are generated and if there's any handling for them
echo "Checking for source map handling in development builds..."
rg -n "\.map" build.mjs
rg -n "source-map" build.mjs

# Check if copyFiles function handles .map files
ast-grep --pattern 'copyFiles($$$)'

---

506-558: Consider extracting duplicated webpack build logic

The production build contains significant code duplication between parallel and sequential builds. This pattern of wrapping runWebpack in promises is repeated multiple times.

Consider refactoring to reduce duplication:

+function createWebpackBuildPromise(isWithoutKatex, isWithoutTiktoken, minimal, tmpDir, suffix) {
+  return new Promise((resolve, reject) =>
+    runWebpack(isWithoutKatex, isWithoutTiktoken, minimal, tmpDir, async (err, stats) => {
+      if (err || stats.hasErrors()) {
+        console.error(err || stats.toString())
+        reject(err || new Error('webpack error'))
+        return
+      }
+      await finishOutput(suffix, tmpDir)
+      resolve()
+    })
+  )
+}

 async function build() {
   await deleteOldDir()
   if (isProduction && !isAnalyzing) {
     const tmpFull = `${outdir}/.tmp-full`
     const tmpMin = `${outdir}/.tmp-min`
+    
+    const buildMin = () => createWebpackBuildPromise(true, true, true, tmpMin, '-without-katex-and-tiktoken')
+    const buildFull = () => createWebpackBuildPromise(false, false, false, tmpFull, '')
+    
     if (parallelBuild) {
-      await Promise.all([
-        new Promise((resolve, reject) =>
-          runWebpack(true, true, true, tmpMin, async (err, stats) => {
-            // ... duplicated code
-          }),
-        ),
-        new Promise((resolve, reject) =>
-          runWebpack(false, false, false, tmpFull, async (err, stats) => {
-            // ... duplicated code
-          }),
-        ),
-      ])
+      await Promise.all([buildMin(), buildFull()])
     } else {
-      await new Promise((resolve, reject) =>
-        runWebpack(true, true, true, tmpMin, async (err, stats) => {
-          // ... duplicated code
-        }),
-      )
-      await new Promise((resolve, reject) =>
-        runWebpack(false, false, false, tmpFull, async (err, stats) => {
-          // ... duplicated code
-        }),
-      )
+      await buildMin()
+      await buildFull()
     }
     await fs.rm(tmpFull, { recursive: true, force: true })
     await fs.rm(tmpMin, { recursive: true, force: true })
     return
   }
   // ... rest of the function
 }

---

98-104: Consider using a more stable cache key

Including the full sourceBuildDir path in the cache key may cause unnecessary cache invalidation when build directories change between runs.

 const variantId = [
   isWithoutKatex ? 'no-katex' : 'with-katex',
   isWithoutTiktoken ? 'no-tiktoken' : 'with-tiktoken',
   minimal ? 'minimal' : 'full',
-  sourceBuildDir || outdir,
+  path.basename(sourceBuildDir || outdir),
   isProduction ? 'prod' : 'dev',
 ].join('|')

---

420-436: Critical: Build may silently skip missing artifacts

The copyFiles function now silently skips missing files when fs.pathExists returns false, which could lead to incomplete builds being published without any failure signal. While CSS placeholders in dev mode are acceptable, critical JS files should never be skipped silently.

Consider failing the build for missing critical files:

 async function copyFiles(entryPoints, targetDir) {
   if (!fs.existsSync(targetDir)) await fs.mkdir(targetDir, { recursive: true })
   await Promise.all(
     entryPoints.map(async (entryPoint) => {
       try {
         if (await fs.pathExists(entryPoint.src)) {
           await fs.copy(entryPoint.src, `${targetDir}/${entryPoint.dst}`)
         } else {
-          // Skip missing CSS in development (placeholders will be created later)
           const isCss = String(entryPoint.dst).endsWith('.css')
-          if (!isProduction || isCss) {
-            if (!isProduction && isCss) return
+          // Only skip CSS files in development (placeholders will be created)
+          if (!isProduction && isCss) {
+            console.log(`Skipping missing CSS in dev: ${entryPoint.src}`)
+            return
           }
+          // For all other files or production builds, this is a critical error
           throw new Error(`Missing build artifact: ${entryPoint.src}`)
         }
       } catch (e) {
         console.error('Copy failed:', entryPoint, e)
         throw e
       }
     }),
   )
 }

build.mjs (1)

401-415: Add error handling for directory creation in zipFolder

The zipFolder function should ensure the parent directory exists before creating the zip file.

The implementation correctly uses fs.ensureDir to create parent directories, and the Promise-based error handling is comprehensive. Good implementation!

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you open a pull request for review, mark a draft as ready, or comment "@codex review". If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex fix this CI failure" or "@codex address that feedback".

build.mjs (3)

91-98: Stabilize cache key: avoid absolute paths in variantId to improve cache hits across environments

Using sourceBuildDir or outdir directly can include absolute paths, fragmenting cache keys between CI/local. Normalize to a relative path.

   const variantId = [
     isWithoutKatex ? 'no-katex' : 'with-katex',
     isWithoutTiktoken ? 'no-tiktoken' : 'with-tiktoken',
     minimal ? 'minimal' : 'full',
-    sourceBuildDir || outdir,
+    path.relative(process.cwd(), sourceBuildDir || outdir),
     isProduction ? 'prod' : 'dev',
   ].join('|')

---

376-389: Fix watch-once: await async callback before closing watcher/exiting

When BUILD_WATCH_ONCE is set, the code exits before async work in the callback (e.g., finishOutput) completes, yielding partial outputs. Await the returned promise before closing the watcher and exiting.

-    const watching = compiler.watch({}, (err, stats) => {
+    const watching = compiler.watch({}, (err, stats) => {
       const hasErrors = !!(
         err ||
         (stats && typeof stats.hasErrors === 'function' && stats.hasErrors())
       )
-      callback(err, stats)
-      if (process.env.BUILD_WATCH_ONCE) {
-        watching.close((closeErr) => {
-          if (closeErr) console.error('Error closing watcher:', closeErr)
-          // Exit explicitly to prevent hanging processes in CI
-          // Use non-zero exit code when errors occurred
-          process.exit(hasErrors || closeErr ? 1 : 0)
-        })
-      }
+      const ret = callback(err, stats)
+      const finalize = () =>
+        watching.close((closeErr) => {
+          if (closeErr) console.error('Error closing watcher:', closeErr)
+          process.exit(hasErrors || closeErr ? 1 : 0)
+        })
+      if (process.env.BUILD_WATCH_ONCE) {
+        if (ret && typeof ret.then === 'function') ret.then(finalize, finalize)
+        else finalize()
+      }
     })

---

123-124: Dev source maps: either copy .map files or revert to inline to avoid 404s in unpacked extension

With devtool set to cheap-module-source-map, bundles reference external *.js.map files, but finishOutput doesn’t copy them, causing broken source maps in the browser. Choose one:

Option A — copy maps:

@@
-    devtool: isProduction ? false : 'cheap-module-source-map',
+    devtool: isProduction ? false : 'cheap-module-source-map',
@@
-async function finishOutput(outputDirSuffix, sourceBuildDir = outdir) {
+async function finishOutput(outputDirSuffix, sourceBuildDir = outdir) {
+  const mapFiles = isProduction
+    ? []
+    : [
+        { src: `${sourceBuildDir}/shared.js.map`, dst: 'shared.js.map' },
+        { src: `${sourceBuildDir}/content-script.js.map`, dst: 'content-script.js.map' },
+        { src: `${sourceBuildDir}/background.js.map`, dst: 'background.js.map' },
+        { src: `${sourceBuildDir}/popup.js.map`, dst: 'popup.js.map' },
+        { src: `${sourceBuildDir}/IndependentPanel.js.map`, dst: 'IndependentPanel.js.map' },
+      ]
@@
-  await copyFiles(
-    [...commonFiles, { src: 'src/manifest.json', dst: 'manifest.json' }],
+  await copyFiles(
+    [...commonFiles, ...mapFiles, { src: 'src/manifest.json', dst: 'manifest.json' }],
     chromiumOutputDir,
   )
@@
-  await copyFiles(
-    [...commonFiles, { src: 'src/manifest.v2.json', dst: 'manifest.json' }],
+  await copyFiles(
+    [...commonFiles, ...mapFiles, { src: 'src/manifest.v2.json', dst: 'manifest.json' }],
     firefoxOutputDir,
   )

Option B — revert to inline source maps in dev:

-    devtool: isProduction ? false : 'cheap-module-source-map',
+    devtool: isProduction ? false : 'inline-source-map',

Run to confirm maps are included after applying Option A:

#!/bin/bash
rg -n "js\.map" -C2 build.mjs && echo "---" && rg -n "shared\.js\.map|content-script\.js\.map|background\.js\.map|popup\.js\.map|IndependentPanel\.js\.map" -C1

Also applies to: 438-456, 460-463, 480-483

build.mjs (3)

411-411: Prefer fs.ensureDir for idempotent directory creation

Slightly simpler and race-safe.

-  if (!fs.existsSync(targetDir)) await fs.mkdir(targetDir, { recursive: true })
+  await fs.ensureDir(targetDir)

---

187-187: Document resolve.symlinks: false and its implications

This can affect npm/pnpm link and workspace symlinks. Add a note in docs (Build Performance or Bootstrap) about potential impact and workarounds.

---

499-571: Deduplicate build variant orchestration to reduce boilerplate

The Promise wrapping for the two production variants is repeated. Extract a small helper to run webpack and finishOutput to cut duplication and lower error surface.

Example:

function webpackRunPromise(args, suffix, dir) {
  return new Promise((resolve, reject) =>
    runWebpack(...args, async (err, stats) => {
      if (err || stats.hasErrors()) {
        console.error(err || stats.toString())
        reject(err || new Error('webpack error'))
        return
      }
      await finishOutput(suffix, dir)
      resolve()
    }),
  )
}

// Usage:
const buildMin = () => webpackRunPromise([true, true, true, tmpMin], '-without-katex-and-tiktoken', tmpMin)
const buildFull = () => webpackRunPromise([false, false, false, tmpFull], '', tmpFull)

.github/copilot-instructions.md (3)

33-35: Tighten grammar/punctuation for clarity

Add commas around parenthetical phrases.

-Performance defaults: esbuild handles JS/CSS minification; in development CSS is injected via style-loader;
-in production CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.
+Performance defaults: esbuild handles JS/CSS minification; in development, CSS is injected via style-loader;
+in production, CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.

---

20-32: Document symlink behavior (resolve.symlinks: false) and local-link caveats

Add a short note so contributors using npm/pnpm link aren’t surprised.

Suggested addition:

• Note: Webpack is configured with resolve.symlinks: false to speed up/normalize module resolution. If you use npm link or pnpm workspaces with symlinked deps, local changes may not be picked up as expected. Workarounds: avoid symlinked deps for this repo, or temporarily enable symlink resolution in build.mjs while developing the linked package.

---

36-47: Mention dev source maps location/expectations

Since dev builds emit external source maps, note that .map files are included in build/* outputs to keep DevTools happy.

Suggested addition:

• Development: Bundles reference external source maps (.js.map). These files are copied into build/chromium/ and build/firefox*/ so DevTools can load them without 404s. If you don’t need source maps, set BUILD_SOURCEMAPS=0 (future option) or switch to inline maps locally.

Also applies to: 104-117

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

build.mjs (3)

423-449: Avoid TOCTOU on copy; let fs.copy fail and handle ENOENT.

Removes the race between pathExists and copy while keeping dev CSS skip behavior.

 async function copyFiles(entryPoints, targetDir) {
   if (!fs.existsSync(targetDir)) await fs.mkdir(targetDir, { recursive: true })
   await Promise.all(
     entryPoints.map(async (entryPoint) => {
-      try {
-        if (await fs.pathExists(entryPoint.src)) {
-          await fs.copy(entryPoint.src, `${targetDir}/${entryPoint.dst}`)
-        } else {
-          // Skip missing CSS in development (placeholders will be created later)
-          const isCss = String(entryPoint.dst).endsWith('.css')
-          if (!isProduction || isCss) {
-            if (!isProduction && isCss) {
-              console.log(
-                `[build] Skipping missing CSS file: ${entryPoint.src} -> ${entryPoint.dst} (placeholder will be created)`,
-              )
-              return
-            }
-          }
-          throw new Error(`Missing build artifact: ${entryPoint.src}`)
-        }
-      } catch (e) {
-        console.error('Copy failed:', entryPoint, e)
-        throw e
-      }
+      try {
+        await fs.copy(entryPoint.src, `${targetDir}/${entryPoint.dst}`)
+      } catch (e) {
+        const isCss = String(entryPoint.dst).endsWith('.css')
+        if (e && e.code === 'ENOENT') {
+          if (!isProduction && isCss) {
+            console.log(
+              `[build] Skipping missing CSS file: ${entryPoint.src} -> ${entryPoint.dst} (placeholder will be created)`,
+            )
+            return
+          }
+          console.error('Missing build artifact:', entryPoint.src)
+        } else {
+          console.error('Copy failed:', entryPoint, e)
+        }
+        throw e
+      }
     }),
   )
 }

---

451-469: Dev source maps aren’t copied; DevTools shows 404s. Add .map copies in dev.

Since devtool is cheap-module-source-map, include emitted maps alongside bundles.

 async function finishOutput(outputDirSuffix, sourceBuildDir = outdir) {
-  const commonFiles = [
+  const commonFiles = [
     { src: 'src/logo.png', dst: 'logo.png' },
     { src: 'src/rules.json', dst: 'rules.json' },
 
     { src: `${sourceBuildDir}/shared.js`, dst: 'shared.js' },
     { src: `${sourceBuildDir}/content-script.css`, dst: 'content-script.css' }, // shared
 
     { src: `${sourceBuildDir}/content-script.js`, dst: 'content-script.js' },
 
     { src: `${sourceBuildDir}/background.js`, dst: 'background.js' },
 
     { src: `${sourceBuildDir}/popup.js`, dst: 'popup.js' },
     { src: `${sourceBuildDir}/popup.css`, dst: 'popup.css' },
     { src: 'src/popup/index.html', dst: 'popup.html' },
 
     { src: `${sourceBuildDir}/IndependentPanel.js`, dst: 'IndependentPanel.js' },
     { src: 'src/pages/IndependentPanel/index.html', dst: 'IndependentPanel.html' },
-  ]
+    // Dev-only: copy external source maps for CSP-safe debugging
+    ...(isProduction
+      ? []
+      : [
+          { src: `${sourceBuildDir}/content-script.js.map`, dst: 'content-script.js.map' },
+          { src: `${sourceBuildDir}/background.js.map`, dst: 'background.js.map' },
+          { src: `${sourceBuildDir}/popup.js.map`, dst: 'popup.js.map' },
+          { src: `${sourceBuildDir}/IndependentPanel.js.map`, dst: 'IndependentPanel.js.map' },
+        ]),
+  ]

---

370-404: Watch-once may exit before async finishOutput completes. Await the callback.

Process can terminate early, leaving partial outputs. Chain the promise before closing watcher/exiting.

   } else {
-    const watching = compiler.watch({}, (err, stats) => {
+    const watching = compiler.watch({}, (err, stats) => {
       const hasErrors = !!(
         err ||
         (stats && typeof stats.hasErrors === 'function' && stats.hasErrors())
       )
-      callback(err, stats)
+      const ret = callback(err, stats)
       if (process.env.BUILD_WATCH_ONCE) {
-        watching.close((closeErr) => {
-          if (closeErr) console.error('Error closing watcher:', closeErr)
-          // Exit explicitly to prevent hanging processes in CI
-          // Use non-zero exit code when errors occurred
-          process.exit(hasErrors || closeErr ? 1 : 0)
-        })
+        const finalize = () =>
+          watching.close((closeErr) => {
+            if (closeErr) console.error('Error closing watcher:', closeErr)
+            process.exit(hasErrors || closeErr ? 1 : 0)
+          })
+        if (ret && typeof ret.then === 'function') {
+          ret.then(finalize, finalize)
+        } else {
+          finalize()
+        }
       }
     })
   }

.github/copilot-instructions.md (3)

32-33: Fix list indentation to satisfy markdownlint (MD005/MD007).

Align top-level and sub-bullets consistently.

- - BUILD_WATCH_ONCE (dev): When set, `npm run dev` runs a single build and exits (useful for timing)
- - BUILD_POOL_TIMEOUT: Override thread-loader production pool timeout (ms)
-   - Default: `2000`. Increase if workers recycle too aggressively on slow machines/CI
+ - BUILD_WATCH_ONCE (dev): When set, `npm run dev` runs a single build and exits (useful for timing)
+- BUILD_POOL_TIMEOUT: Override thread-loader production pool timeout (ms)
+  - Default: `2000`. Increase if workers recycle too aggressively on slow machines/CI

---

35-37: Tighten grammar and readability in “Performance defaults.”

Capitalize clauses and use commas/periods for clarity.

-Performance defaults: esbuild handles JS/CSS minification; in development CSS is injected via style-loader;
-in production CSS is extracted via MiniCssExtractPlugin; thread-loader is enabled by default in both dev and prod.
+Performance defaults: esbuild handles JS/CSS minification. In development, CSS is injected via style-loader;
+in production, CSS is extracted via MiniCssExtractPlugin. Thread-loader is enabled by default in both dev and prod.

---

20-37: Document source map behavior (external .map files in dev).

Dev builds use external source maps; call out that .map files are written next to bundles to avoid DevTools 404s and that production builds omit them.

 - BUILD_WATCH_ONCE (dev): When set, `npm run dev` runs a single build and exits (useful for timing)
+- Source maps (dev): External `.map` files are emitted next to JS bundles for CSP‑safe debugging; production builds disable source maps.

build.mjs (2)

136-151: Cache invalidation: include lockfiles/package.json in filesystem cache deps.

Without these, cache may go stale when deps change.

   cache: {
     type: 'filesystem',
     name: `webpack-${variantId}`,
     version: JSON.stringify({
       THREAD: enableThread,
       WORKERS: threadWorkers,
       CACHE_COMP: cacheCompressionOption ?? false,
       PROD: isProduction,
     }),
     // default none; override via BUILD_CACHE_COMPRESSION=gzip|brotli
     compression: cacheCompressionOption ?? false,
     buildDependencies: {
-      config: [path.resolve('build.mjs')],
+      config: [
+        path.resolve('build.mjs'),
+        path.resolve('package.json'),
+        path.resolve('package-lock.json'),
+        path.resolve('pnpm-lock.yaml'),
+        path.resolve('yarn.lock'),
+      ],
     },
   },

---

199-205: Resolve.symlinks=false can surprise linked dev setups; document it.

Add a short comment here and a note in docs about pnpm/npm link implications and why it’s set.

Would you like me to add a brief blurb under “Build Performance Options” explaining this choice?

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you open a pull request for review, mark a draft as ready, or comment "@codex review". If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex fix this CI failure" or "@codex address that feedback".